home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 June: Reference Library / Dev.CD Jun 94.toast / Periodicals / develop / develop Issue 15 / develop 15 code / Symmetry & Tiles / Tiler Code / Sludge < prev    next >
Encoding:
Text File  |  1993-05-31  |  7.5 KB  |  331 lines  |  [TEXT/KAHL]
  1. /*                       gxShape        tempShape;
  2.                       
  3.                       tempShape = GXCopyToShape(nil, hitShape);
  4.                       GXPrimitiveShape(tempShape);
  5.                       SetShapeCommonColor(oldShape, kBGColor);
  6.                       GXPrimitiveShape(oldShape);
  7.                       // Erase part of old shape
  8.                       GXDifferenceShape(oldShape, tempShape);
  9.                       GXDrawShape(oldShape);
  10.                       // Draw new
  11.                       GXDrawShape(hitShape);
  12.                       GXDisposeShape(tempShape);
  13.  */
  14.  
  15.  
  16. void TrackOpShape(short whichShape, gxPoint *clickPt, gxHitTestInfo *hitStats)
  17. {
  18.     gxPoint        pt, lastPt = *clickPt, anchor;
  19.     gxShape        dragShape = gOpShapes[whichShape], tempShape;
  20.     fixed        theLine[4];
  21.     Boolean        redraw;
  22.     
  23.     
  24.     // Set up
  25.     switch(gSymmetry)
  26.     {
  27.         case p1:
  28.             p1_GetRefPoint(dragShape, &anchor);
  29.             break;
  30.             
  31.         case pg:    // these are all pairs of vertical line shapes
  32.         case pm:
  33.         case cm:
  34.             pg_GetRefPoint(dragShape, &anchor);
  35.             break;
  36.  
  37.         case p2:
  38.             p2_GetRefPoint(dragShape, &anchor);
  39.             break;
  40.             
  41.         default:
  42.             break;
  43.     }
  44.     
  45.     if(!gContRedraw)
  46.     {
  47.         tempShape = GXCopyToShape(nil, dragShape);
  48.     }
  49.     
  50.     // Follow the drag around
  51.     while(StillDown())
  52.     {
  53.         GXGetViewPortMouse(0, &pt);
  54.         if(pt.x != lastPt.x || pt.y != lastPt.y)
  55.         {
  56.             // Save old shape so we can erase and draw in rapid succession
  57.             if(!gContRedraw)
  58.             {
  59.                 GXCopyToShape(tempShape, dragShape);
  60.             }
  61.             
  62.             // move the shape appropriately
  63.             switch(gSymmetry)
  64.             {
  65.                 case p1:    // Track translation arrow head
  66.                     p1_DragOpShape(dragShape, &pt, &anchor);
  67.                     redraw = true;
  68.                     break;
  69.                 
  70.                 case pg:    // lines moving horizontally only
  71.                 case pm:
  72.                 case cm:
  73.                     pg_DragOpShape(dragShape, &pt, &anchor);
  74.                     redraw = true;
  75.                     break;
  76.         
  77.                 case p2:
  78.                     p2_DragOpShape(dragShape, &pt, &anchor);
  79.                     redraw = true;
  80.                     break;
  81.                 
  82.                 default:
  83.                     break;
  84.             }
  85.             
  86.             if(redraw)
  87.             {
  88.                 redraw = false;
  89.                 if(gContRedraw)
  90.                 {
  91.                     // Reset pattern and draw it right now
  92.                     LatticeChanged();
  93.                       GXDrawShape(gOffScreen.draw);
  94.                 }
  95.                   else
  96.                   {
  97. /*                       gxShape primDrag;
  98.                     
  99.                     primDrag = GXCopyToShape(nil, dragShape);
  100.                     SetShapeCommonColor(primDrag, kBGColor);
  101.                     GXPrimitiveShape(primDrag);
  102.                     GXPrimitiveShape(tempShape);
  103.                     GXDifferenceShape (tempShape, primDrag);
  104.                     GXDrawShape (tempShape);
  105.                     GXDisposeShape(primDrag);
  106.  */                    
  107.                     // Erase and draw
  108.                     EraseAShape(tempShape);
  109.                     GXDrawShape(dragShape);
  110.                   }
  111.               }
  112.               
  113.           }
  114.           lastPt = pt;
  115.     }
  116.     if(!gContRedraw)
  117.     {
  118.         GXDisposeShape(tempShape);
  119.         LatticeChanged();
  120.     }
  121. }
  122.  
  123.  
  124. Boolean    IsVectorPoint(long ptIndex);
  125. void    GetVectorPoint(short whichPt, point *thePt);
  126. void    SetVectorPoint(short whichPt, point *thePt);
  127.  
  128. // Returns true if the given point is one of the vector-determining points
  129. // in the dragger, false otherwise
  130. Boolean IsVectorPoint(long ptIndex)
  131. {
  132.     return(    ptIndex == gDragger.Odex ||
  133.             ptIndex == gDragger.Udex ||
  134.             ptIndex == gDragger.Vdex  );
  135. }
  136.  
  137. // Returns a vector-determining point
  138. void GetVectorPoint(short whichPt, point *thePt)
  139. {
  140.     if(whichPt == gDragger.Odex)
  141.         GetShapePoints(gDragger.snake1, gDragger.Odex, 1, thePt);
  142.     else if(whichPt == gDragger.Vdex)
  143.         GetShapePoints(gDragger.snake1, gDragger.Vdex, 1, thePt);
  144.     else if(whichPt == gDragger.Udex)
  145.         GetShapePoints(gDragger.snake1, gDragger.Udex, 1, thePt);
  146. }
  147.  
  148. void SetVectorPoint(short whichPt, point *thePt)
  149. {
  150.     if(whichPt == gDragger.Odex)
  151.         SetShapePoints(gDragger.snake1, gDragger.Odex, 1, thePt);
  152.     else if(whichPt == gDragger.Vdex)
  153.         SetShapePoints(gDragger.snake1, gDragger.Vdex, 1, thePt);
  154.     else if(whichPt == gDragger.Udex)
  155.         SetShapePoints(gDragger.snake1, gDragger.Udex, 1, thePt);
  156. }
  157.  
  158.  
  159.  
  160.  
  161. -----------------------------------------------------------------------
  162.     // point constraining variables
  163.     long    slaveIndex = -1;
  164.     point    slavePt;
  165.     long    slaveConstraint = constrainNone;
  166.     fixed    hOffset, vOffset;
  167.     
  168.     // Set up point constraints if a vector-determining point
  169.     if(isVectorPoint)
  170.     {
  171. /*         switch(gSymmetry)
  172.         {
  173.             case p1: // No constraints
  174.                 break;
  175.             
  176.             // Slave the origin to the end points, don't drag origin
  177.             case pg:
  178.             case cm:
  179.                 if(dragPtIndex == gDragger.Odex) // Can't drag origin
  180.                 {
  181.                     SysBeep(10);
  182.                     return;
  183.                 }
  184.                 else
  185.                 {
  186.                     if(dragPtIndex == gDragger.Udex)
  187.                         slaveConstraint = constrainV;
  188.                     else
  189.                         slaveConstraint = constrainH;
  190.                     slaveIndex = gDragger.Odex;
  191.                 }
  192.                 break;
  193.             
  194.             // Slave the origin to V and vice versa
  195.             case pm:
  196.                 if(dragPtIndex != gDragger.Udex) // U is the only vector point not constrained
  197.                 {
  198.                     slaveConstraint = constrainH;
  199.                     if(dragPtIndex == gDragger.Odex)
  200.                         slaveIndex = gDragger.Vdex;
  201.                     else
  202.                         slaveIndex = gDragger.Odex;
  203.                 }
  204.                 break;
  205.             
  206.             // O_ point is active: Slave O_ to any other point
  207.             case p2:
  208.                 if(dragPtIndex == gDragger.Odex)
  209.                 {
  210.                 slaveConstraint = constrainO_;
  211.                     slaveIndex = gDragger.O_dex;
  212.                 }
  213.                 else
  214.                 {
  215.                     // slave O_ to U or V
  216.                     slaveConstraint = constrainBoth;
  217.                     slaveIndex = gDragger.O_dex;
  218.                 }
  219.                 break;
  220.             
  221.             default:
  222.                 break;
  223.         }
  224.         
  225.         // Get the actual slave point and set up offsets
  226.         if(slaveConstraint & constrainBoth)
  227.         {
  228.             point dragPt;
  229.             
  230.             GetVectorPoint(slaveIndex, &slavePt);
  231.             GetVectorPoint(dragPtIndex, &dragPt);
  232.             hOffset = slavePt.x - dragPt.x;
  233.             vOffset = slavePt.y - dragPt.y;
  234.         }
  235.     } */
  236. ---------------------------------------------------------------------
  237. ---------------------------------------------------------------------
  238.  
  239.             // Set the slave, if there is one
  240. /*             if(slaveIndex >= 0)
  241.             {
  242.                 if(slaveConstraint & constrainBoth)
  243.                 {
  244.                     // Check for the bits individually
  245.                     if(slaveConstraint & constrainH)
  246.                         slavePt.x = pt.x + hOffset;
  247.                     if(slaveConstraint & constrainV)
  248.                         slavePt.y = pt.y + vOffset;
  249.                 }
  250.                                 
  251.                 // Always a vector point, if slaved
  252.                 SetVectorPoint(slaveIndex, &slavePt);
  253.             }
  254.  */            
  255.  
  256. ---------------------------------------------------------------------
  257. ---------------------------------------------------------------------
  258.  
  259.     point    origin, temp;
  260.     
  261. /*     GetVectorPoint(gDragger.Odex, &origin);
  262.     switch(gSymmetry)
  263.     {
  264.         case p1:    // no constraints
  265.             break;
  266.             
  267.          case pg:    // must be rectangular, one contour V to U
  268.                  // Force rectangular
  269.             GetVectorPoint(gDragger.Udex, &temp);
  270.             temp.y = origin.y;
  271.             SetVectorPoint(gDragger.Udex, &temp);
  272.             GetVectorPoint(gDragger.Vdex, &temp);
  273.             temp.x = origin.x;
  274.             SetVectorPoint(gDragger.Vdex, &temp);
  275.             break;
  276.             
  277.          case pm:    // V below O
  278.         case cm:    // rectangular
  279.             // Force V below O
  280.             GetVectorPoint(gDragger.Vdex, &temp);
  281.             temp.x = origin.x;
  282.             SetVectorPoint(gDragger.Vdex, &temp);
  283.              if(gSymmetry == cm)
  284.              {
  285.                  // Force horizontal, too.
  286.                 GetVectorPoint(gDragger.Udex, &temp);
  287.                 temp.y = origin.y;
  288.                 SetVectorPoint(gDragger.Udex, &temp);
  289.              }
  290.             break;
  291.  
  292.         default:
  293.             DefaultTileAndPattern();
  294.             break;
  295.     } */
  296.     
  297. ----------------------------------
  298. -_------------------------------------
  299.  
  300.  
  301.  
  302.             line    extraLine;
  303.  
  304.             // Add lines to close off square tiles
  305.             ctr = origin;
  306.             extraLine.first = ctr;
  307.             ctr.y += gPattern.v.y;
  308.             extraLine.last = ctr;
  309.             tempShape = NewLine(&extraLine);
  310.             SetShapeParts(gTileShape, 0, selectToEnd, tempShape, breakLeftEdit);
  311.             ctr = origin;
  312.             ctr.x += gPattern.u.x / 2;
  313.             extraLine.first = ctr;
  314.             ctr.y += gPattern.v.y;
  315.             extraLine.last = ctr;
  316.             SetLine(tempShape, &extraLine);
  317.             SetShapeParts(gTileShape, 0, selectToEnd, tempShape, breakLeftEdit);
  318.             DisposeShape(tempShape);
  319.             
  320. ==================
  321.             // Add a line to close off tiles
  322.             ctr = origin;
  323.             extraLine.first = ctr;
  324.             ctr.y += gPattern.v.y;
  325.             extraLine.last = ctr;
  326.             tempShape = NewLine(&extraLine);
  327.             SetShapeParts(gTileShape, 0, selectToEnd, tempShape, breakLeftEdit);
  328.             DisposeShape(tempShape);
  329.             
  330.  
  331.